Hoy en día las interfaces de los programas son cada vez más sofisticadas y atractivas par el usuario. Son intuitivas y cada vez más fáciles de usar: pantallas táctiles, etc.

Sin embargo, no siempre ha sido así. No hace muchos años, antes de que surgieran y se popularizaran las interfaces gráficas de usuario para que el usuario interactuara con el sistema operativo con sistemas como Windows, etc., se trabajaba en modo consola, o modo carácter, es decir, se le daban las ordenes al ordenador con comandos por teclado, de hecho, por entonces no existía el ratón.

Así que, con el tiempo, con la idea de simplificar el uso de los ordenadores para extender el uso a un cada vez mayor espectro de gente, de usuarios de todo tipo, y no sólo para los expertos, se ha convertido en una práctica habitual utilizar interfaces gráficas de usuario (IGU ó GUI en inglés), para que el usuario interactúe y establezca un contacto más fácil e intuitivo con el ordenador.

En ocasiones verás otras definiciones de interfaz, como la que define una interfaz como un dispositivo que permite comunicar dos sistemas que no hablan el mismo lenguaje. También se emplea el término interfaz para definir el juego de conexiones y dispositivos que hacen posible la comunicación entre dos sistemas.

Aquí en este módulo, cuando hablamos de interfaz nos referimos a la cara visible de los programas tal y como se presenta a los usuarios para que interactúen con la máquina. La interfaz gráfica implica la presencia de un monitor de ordenador, en el que veremos la interfaz constituida por una serie de menús e iconos que representan las opciones que el usuario puede tomar dentro del sistema.

Las interfaces gráficas de usuario proporcionan al usuario ventanas, cuadros de diálogo, barras de herramientas, botones, listas desplegables y muchos otros elementos. Las aplicaciones son conducidas por eventos y se desarrollan haciendo uso de las clases que para ello nos ofrece el API de Java.

Hemos visto que la interfaz gráfica de usuario es la parte del programa que permite al usuario interaccionar con él. Pero, ¿cómo la podemos crear en Java?

El API de Java proporciona una librería de clases para el desarrollo de interfaces gráficas de usuario (en realidad son dos: AWT y Swing). Esas librerías se engloban bajo los nombres de AWT y Swing, que a su vez forman parte de las Java Foundation Classes o JFC. AWT es una librería ya en desuso y en la actualidad Swing está siendo desplazado por JavaFX, plataforma que permite el desarrollo de interfaces gráficas de usuario con grandes prestaciones y ejecutables en cualquier plataforma (pc, móviles, web, etc). JavaFX es una tecnología de Oracle que no está incluída en JDK pero está a disposición de los usuarios que deseen utilizarla. Sin duda JavaFX marcará el futuro de las interfaces gráficas en Java, pues además es compatible con componentes Swing.

Entre las clases de las JFC hay un grupo de elementos importante que ayuda a la construcción de interfaces gráficas de usuario (GUI) en Java.

Los elementos que componen las JFC son:

• Componentes Swing: encontramos componentes tales como botones, cuadros de texto, ventanas o elementos de menú.
• Soporte de diferentes aspectos y comportamientos (Look and Feel): permite la elección de diferentes apariencias de entorno. Por ejemplo, el mismo programa puede adquirir un aspecto Metal Java (multiplataforma, igual en cualquier entorno), Motif (el aspecto estándar para entornos Unix) o Windows (para entornos Windows). De esta forma, el aspecto de la aplicación puede ser independiente de la plataforma, lo cual está muy bien para un lenguaje que lleva la seña de identidad de multiplataforma, y se puede elegir el que se desee en cada momento.
• Interfaz de programación Java 2D: permite incorporar gráficos en dos dimensiones, texto e imágenes de alta calidad.
• Soporte de arrastrar y soltar (Drag and Drop) entre aplicaciones Java y aplicaciones nativas. Es decir, se implementa un portapapeles. Llamamos aplicaciones nativas a las que están desarrolladas en un entorno y una plataforma concretos (por ejemplo Windows o Unix), y sólo funcionarán en esa plataforma.
• Soporte de impresión.
• Soporte sonido: captura, reproducción y procesamiento de datos de audio y MIDI
• Soporte de dispositivos de entrada distintos del teclado, para japonés, chino, etc.
• Soporte de funciones de Accesibilidad, para crear interfaces para discapacitados: permite el uso de tecnologías como los lectores de pantallas o las pantallas Braille adaptadas a las personas discapacitadas.

Con estas librerías, Java proporciona un conjunto de herramientas para la construcción de interfaces gráficas que tienen una apariencia y se comportan de forma semejante en todas las plataformas en las que se ejecuten.

El objetivo de esta unidad es hacer una introducción a la construcción de interfaces gráficas con Java utiilzando las dos plataformas más utilizadas: Swing y JavaFX. Se trabajarán los conceptos básicos que permitirán una primera tomar de contacto con en el mundo de las interfaces gráficas de usuario.  Todos estas contenidos serán trabajados en profundidad en el Módulo Profesional "Interfaces de Usuario" de segundo curso.

Cuando se vio que era necesario mejorar las características que ofrecía AWT, distintas empresas empezaron a sacar sus controles propios para mejorar algunas de las características de AWT. Así, Netscape sacó una librería de clases llamada Internet Foundation Classes para usar con Java, y eso obligó a Sun (todavía no adquirida por Oracle) a reaccionar para adaptar el lenguaje a las nuevas necesidades.

Se desarrolló en colaboración con Netscape todo el conjunto de componentes Swing que se añadieron a la JFC.

Swing es una librería de Java para la generación del GUI en aplicaciones.

Swing se apoya sobre AWT y añade JComponents. La arquitectura de los componentes de Swing facilita la personalización de apariencia y comportamiento, si lo comparamos con los componentes AWT.

Por cada componente AWT (excepto Canvas) existe un componente Swing equivalente, cuyo nombre empieza por J, que permite más funcionalidad siendo menos pesado. Así, por ejemplo, para el componente AWT Button existe el equivalente Swing JButton, que permite como funcionalidad adicional la de crear botones con distintas formas (rectangulares, circulares, etc), incluir imágenes en el botón, tener distintas representaciones para un mismo botón según esté seleccionado, o bajo el cursor, etc.

La razón por la que no existe JCanvas es que los paneles de la clase JPanel ya soportan todo lo que el componente Canvas de AWT soportaba. No se consideró necesario añadir un componente Swing JCanvas por separado.

Algunas características más de Swing, podemos mencionar:

• Es independiente de la arquitectura (metodología no nativa propia de Java)
• Proporciona todo lo necesario para la creación de entornos gráficos, tales como diseño de menús, botones, cuadros de texto, manipulación de eventos, etc.
• Los componentes Swing no necesitan una ventana propia del sistema operativo cada uno, sino que son visualizados dentro de la ventana que los contiene mediante métodos gráficos, por lo que requieren bastantes menos recursos.
• Las clases Swing están completamente escritas en Java, con lo que la portabilidad es total, a la vez que no hay obligación de restringir la funcionalidad a los mínimos comunes de todas las plataformas
• Por ello las clase Swing aportan una considerable gama de funciones que haciendo uso de la funcionalidad básica propia de AWT aumentan las posibilidades de diseño de interfaces gráficas.
• Debido a sus características, los componentes AWT se llaman componentes “de peso pesado” por la gran cantidad de recursos del sistema que usan, y los componentes Swing se llaman componentes “de peso ligero” por no necesitar su propia ventana del sistema operativo y por tanto consumir muchos menos recursos.
• Aunque todos los componentes Swing derivan de componentes AWT y de hecho se pueden mezclar en una misma aplicación componentes de ambos tipos, se desaconseja hacerlo. Es preferible desarrollar aplicaciones enteramente Swing, que requieren menos recursos y son más portables.

Crear aplicaciones que incluyan interfaces gráficos de usuario, con NetBeans, es muy sencillo debido a las facilidades que nos proporcionan sus asistentes y herramientas.

El IDE de programación nos proporciona un diseñador o editor gráfico para crear aplicaciones de una manera fácil, sin tener que preocuparnos demasiado del código. Simplemente nos debemos centrar en el funcionamiento de las mismas.

Un programador experimentado, probablemente no utilizará los asistentes, sino que escribirá, casi siempre, todo el código de la aplicación. De este modo, podrá indicar por código la ubicación de los diferentes controles, de su interfaz gráfica, en el contenedor (panel, marco, etc.) en el que se ubiquen.

Pero en el caso de programadores novatos, o simplemente si queremos ahorrar tiempo y esfuerzo, tenemos la opción de aprovecharnos de las capacidades que nos brinda un entorno de desarrollo visual para diseñar e implementar formularios gráficos.

Algunas de las características de NetBeans, que ayudan a la generación rápida de aplicaciones, y en particular de interfaces son:

• Modo de diseño libre (Free Design): permite mover libremente los componentes de interfaz de usuario sobre el panel o marco, sin atenerse a uno de los layouts por defecto. Un layout define la posición de los elementos de un panel.
• Independencia de plataforma: diseñando de la manera más fácil, es decir, arrastrando y soltando componentes desde la paleta al área de diseño visual, el NetBeans sugiere alineación, posición, y dimensión de los componentes, de manera que se ajusten para cualquier plataforma, y en tiempo de ejecución el resultado sea el óptimo, sin importar el sistema operativo donde se ejecute la aplicación.
• Soporte de internacionalización: Se pueden internacionalizar las aplicaciones Swing, aportando las traducciones de cadenas de caracteres, imágenes, etc., sin necesidad de tener que reconstruir el proyecto, sin tener que compilarlo según el país al que vaya dirigido. Se puede utilizar esta características empleando ficheros de recursos (ResourceBundle files). En ellos, deberíamos aportar todos los textos visibles, como el texto de etiquetas, campos de texto, botones, etc. NetBeans proporciona una asistente de internacionalización desde el menú de herramientas (Tools).

Los pasos para crear y ejecutar aplicaciones, se pueden resumir en:

• Crear un proyecto.
• Construir la interfaz con el usuario.
• Añadir funcionalidad, en base a la lógica de negocio que se requiera.
• Ejecutar el programa.

Veamos un ejemplo con estos pasos:

• Primero, crea el proyecto de la manera tan simple como puedes ver en:

• A continuación, vamos a crear la interfaz. Se tratará de una ventana con tres campos de texto y varios botones. Obsérvalo en la siguiente presentación:

Has podido comprobar que el diseño de interfaces con el editor gráfico de Netbeans es relativamente sencillo. En otros entornos de desarrollo la forma de proceder es parecida. En las siguientes unidades veremos cómo dar funcionalidad a nuestra aplicación.

¿Qué es un evento?

Es todo hecho que ocurre mientras se ejecuta la aplicación. Normalmente, llamamos evento a cualquier interacción que realiza el usuario con la aplicación, como puede ser:

• pulsar un botón con el ratón;
• hacer doble clic;
• pulsar y arrastrar;
• pulsar una combinación de teclas en el teclado;
• pasar el ratón por encima de un componente;
• salir el puntero de ratón de un componente;
• abrir una ventana;
• etc.

¿Qué es la programación guiada por eventos?

Imagina la ventana de cualquier aplicación, por ejemplo la de un procesador de textos. En esa ventana aparecen multitud de elementos gráficos interactivos, de forma que no es posible que el programador haya previsto todas las posibles entradas que se pueden producir por parte del usuario en cada momento.

Con el control de flujo de programa de la programación imperativa, el programador tendría que estar continuamente leyendo las entradas (de teclado, o ratón, etc) y comprobar para cada entrada o interacción producida por el usuario, de cual se trata de entre todas las posibles, usando estructuras de flujo condicional (if-then-else, switch) para ejecutar el código conveniente en cada caso. Si piensas que para cada opción del menú, para cada botón o etiqueta, para cada lista desplegable, y por tanto para cada componente de la ventana, incluyendo la propia ventana, habría que comprobar todos y cada uno de los eventos posibles, nos damos cuenta de que las posibilidades son casi infinitas, y desde luego impredecibles. Por tanto, de ese modo es imposible solucionar el problema.

Para abordar el problema de tratar correctamente las interacciones del usuario con la interfaz gráfica de la aplicación hay que cambiar de estrategia, y la programación guiada por eventos es una buena solución, veamos cómo funciona el modelo de gestión de eventos.

¿Qué sistema operativo utilizas? ¿Posee un entorno gráfico? Hoy en día, la mayoría de sistemas operativos utilizan interfaces gráficas de usuario. Este tipo de sistemas operativos están continuamente monitorizando el entorno para capturar y tratar los eventos que se producen.

El sistema operativo informa de estos eventos a los programas que se están ejecutando y entonces cada programa decide, según lo que se haya programado, qué hace para dar respuesta a esos eventos.

Cada vez que el usuario realiza una determinada acción sobre una aplicación que estamos programando en Java, un clic sobre el ratón, presionar una tecla, etc., se produce un evento que el sistema operativo transmite a Java.

Java crea un objeto de una determinada clase de evento, y este evento se transmite a un determinado método para que lo gestione.

El modelo de eventos de Java está basado en delegación, es decir, la responsabilidad de gestionar un evento que ocurre en un objeto fuente la tiene otro objeto oyente.

Las fuentes de eventos (event sources) son objetos que detectan eventos y notifican a los receptores que se han producido dichos eventos. Ejemplos de fuentes:

• Botón sobre el que se pulsa o pincha con el ratón.
• Campo de texto que pierde el foco.
• Campo de texto sobre el que se presiona una tecla.
• Ventana que se cierra.
• Etc.

En el apartado anterior de creación de interfaces con ayuda de los asistentes del IDE, vimos lo fácil que es realizar este tipo de programación, ya que el IDE hace muchas cosas, genera código automáticamente por nosotros.

Pero también podríamos hacerlo nosotros todo, si no tuviéramos un IDE como NetBeans, o porque simplemente nos apeteciera hacerlo todo desde código, sin usar asistentes ni diseñadores gráficos. En este caso, los pasos a seguir se pueden resumir en:

1. Crear la clase oyente que implemente la interfaz.
   • Ej. ActionListener: pulsar un botón.
2. Implementar en la clase oyente los métodos de la interfaz.
   • Ej. void actionPerformed(ActionEvent).
3. Crear un objeto de la clase oyente y registrarlo como oyente en uno o más componentes gráficos que proporcionen interacción con el usuario.

Vamos a añadir funcionalidad a nuestra minicalculadora. Cuando el usuario pulse el botón Sumar se debe realizar la suma de los dos números y mostrar el resultado en el campo resultado.

Resumen textual alternativo

En la mayor parte de la literatura escrita sobre Java, encontrarás dos tipos básicos de eventos:

• Físicos o de bajo nivel: que corresponden a un evento hardware claramente identificable. Por ejemplo, se pulsó una tecla (KeyStrokeEvent). Destacar los siguientes:
  • En componentes: ComponentEvent. Indica que un componente se ha movido, cambiado de tamaño o de visibilidad
  • En contenedores: ContainerEvent. Indica que el contenido de un contenedor ha cambiado porque se añadió o eliminó un componente.
  • En ventanas: WindowEvent. Indica que una ventana ha cambiado su estado.
  • FocusEvent, indica que un componente ha obtenido o perdido la entrada del foco.
• Semánticos o de mayor nivel de abstracción: se componen de un conjunto de eventos físicos, que se suceden en un determinado orden y tienen un significado más abstracto. Por ejemplo: el usuario elige un elemento de una lista desplegable (ItemEvent).
  • ActionEvent, ItemEvent, TextEvent, AdjustmentEvent.

Los eventos en Java se organizan en una jerarquía de clases:

• La clase java.util.EventObject es la clase base de todos los eventos en Java.
• La clase java.awt.AWTEvent es la clase base de todos los eventos que se utilizan en la construcción de GUI.
• Cada tipo de evento loqueseaEvent tiene asociada una interfaz loqueseaListener que nos permite definir manejadores de eventos.
• Con la idea de simplificar la implementación de algunos manejadores de eventos, el paquete java.awt.event incluye clases loqueseaAdapter que implementan las interfaces loqueseaListener.

Los eventos de teclado se generan como respuesta a que el usuario pulsa o libera una tecla mientras un componente tiene el foco de entrada.

keyPressed (KeyEvent e)

keyReleased (KeyEvent e)

keyTyped (KeyEvent e)

char getKeyChar()

int getKeyCode()

String getKeyText()

Object getSource()

La clase KeyEvent, define muchas constantes así:

• KeyEventVK_A especifica la tecla A.
• KeyEventVK_ESCAPE especifica la tecla ESCAPE.

Botón en estado normal.

Al pulsar la tecla se disparará el evento KeyPressed.

Al liberar la tecla se genera el evento KeyReleased.

_{José Javier Bermúdez Hernández (CC BY-NC)}

En el siguiente enlace tienes el código del proyecto que te puedes descargar. En él se puede ver un ejemplo del uso eventos. En concreto vemos cómo se están capturando los eventos que se producen al pulsar una tecla y liberarla. El programa escribe en un área de texto las teclas que se oprimen.

Similarmente a los eventos de teclado, los eventos del ratón se generan como respuesta a que el usuario pulsa o libera un botón del ratón, o lo mueve sobre un componente.

mousePressed (MouseEvent e)

mouseReleased (MouseEvent e)

mouseClickerd (MouseEvent e)

mouseEntered (KeyEvent e)

mouseExited (KeyEvent e)

mouseDragged (MouseEvent e)

mouseMoved (MouseEvent e)

MouseWheelMoved (MouseWheelEvent e)

En el siguiente proyecto podemos ver una demostración de un formulario con dos botones. Implementamos un oyente MouseListener y registramos los dos botones para detectar tres de los cinco eventos del interface.

Como se ve en el código, se deja en blanco el cuerpo de mouseEntered y de mouseExited, ya que no nos interesan en este ejemplo. Cuando se desea escuchar algún tipo de evento, de deben implementar todos los métodos del interface para que la clase no tenga que ser definida como abstracta. Para evitar tener que hacer esto, podemos utilizar adaptadores.

En este mismo tema, más arriba, has visto la lista de los principales componentes Swing que se incluyen en la mayoría de las aplicaciones, junto con una breve descripción de su uso, y una imagen que nos de una idea de cual es su aspecto.

También hemos visto un ejemplo de cómo crear con al ayuda de NetBeans unos sencillos programas. Ahora, vamos a ver con mayor detalle, los componentes más típicos utilizados en los programas en Java y cómo incluirlos dentro de una aplicación.

Por los ejemplos vistos hasta ahora, ya te habrás dado cuenta de la necesidad de que cada aplicación "contenga" de alguna forma esos componentes. ¿Qué componentes se usan para contener a los demás?

En Swing esa función la desempeñan un grupo de componentes llamados contenedores Swing.

Existen dos tipos de elementos contenedores:

• Contenedores de alto nivel o "peso pesado".
  • Marcos:JFrame y JDialog para aplicaciones
  • JApplet, para applets.
• Contenedores de bajo nivel o "peso ligero". Son los paneles: JRootPane y JPanel.

Cualquier aplicación, con interfaz gráfico de usuario típica, comienza con la apertura de una ventana principal, que suele contener la barra de título, los botones de minimizar, maximizar/restaurar y cerrar, y unos bordes que delimitan su tamaño.

Esa ventana constituye un marco dentro del cual se van colocando el resto de componentes que necesita el programador: menú, barras de herramientas, barra de estado, botones, casillas de verificación, cuadros de texto, etc.

Esa ventana principal o marco sería el contenedor de alto nivel de la aplicación.

Toda aplicación de interfaz gráfica de usuario Java tiene, al menos, un contenedor de alto nivel.

Los contenedores de alto nivel extienden directamente a una clase similar de AWT, es decir, JFrame extiende de Frame. Es decir, realmente necesitan crear una ventana del sistema operativo independiente para cada uno de ellos.

Los demás componentes de la aplicación no tienen su propia ventana del sistema operativo, sino que se dibujan en su objeto contenedor.

En los ejemplos anteriores del tema, hemos visto que podemos añadir un JFrame desde el diseñador de NetBeans, o bien escribiéndolo directamente por código. De igual forma para los componentes que añadamos sobre el.

Cuando quieres terminar la ejecución de un programa, ¿qué sueles hacer? Pues normalmente pinchar en el icono de cierre de la ventana de la aplicación.

En Swing, una cosa es cerrar una ventana, y otra es que esa ventana deje de existir completamente, o cerrar la aplicación completamente.

• Se puede hacer que una ventana no esté visible, y sin embargo que ésta siga existiendo y ocupando memoria para todos sus componentes, usando el método setVisible(false). En este caso bastaría ejecutar para el JFrame el método setVisible(true) para volver a ver la ventana con todos sus elementos.
• Si queremos cerrar la aplicación, es decir, que no sólo se destruya la ventana en la que se mostraba, sino que se destruyan y liberen todos los recursos (memoria y CPU) que esa aplicación tenía reservados, tenemos que invocar al método System.exit(0).
• También se puede invocar para la ventana JFrame al método dispose(), heredado de la clase Window, que no requiere ningún argumento, y que borra todos los recursos de pantalla usados por esta ventana y por sus componentes, así como cualquier otra ventana que se haya abierto como hija de esta (dependiente de esta). Cualquier memoria que ocupara esta ventana y sus componentes se libera y se devuelve al sistema operativo, y tanto la ventana como sus componentes se marcan como "no representables". Y sin embargo, el objeto ventana sigue existiendo, y podría ser reconstruido invocando al método pack() o la método show(), aunque deberían construir de nuevo toda la ventana.

Las ventanas JFrame de Swing permiten establecer una operación de cierre por defecto con el método setDefaultCloseOperation(), definido en la clase JFrame.
¿Cómo se le indica al método el modo de cerrar la ventana?

Los valores que se le pueden pasar como parámetros a este método son una serie de constantes de clase:

• DO_NOTHING_ON_CLOSE: no hace nada, necesita que el programa maneje la operación en el método windowClosing() de un objeto WindowListener registrado para la ventana.
• HIDE_ON_CLOSE: Oculta de ser mostrado en la pantalla pero no destruye el marco o ventana después de invocar cualquier objeto WindowListener registrado.
• DISPOSE_ON_CLOSE: Oculta y termina (destruye) automáticamente el marco o ventana después de invocar cualquier objeto WindowListener registrado.
• EXIT_ON_CLOSE: Sale de la aplicación usando el método System.exit(0). Al estar definida en JFrame, se puede usar con aplicaciones, pero no con applets.

Los layout managers son fundamentales en la creación de interfaces de usuario, ya que determinan las posiciones de los controles en un contenedor.

En lenguajes de programación para una única plataforma, el problema sería menor porque el aspecto sería fácilmente controlable. Sin embargo, dado que Java está orientado a la portabilidad del código, éste es uno de los aspectos más complejos de la creación de interfaces, ya que las medidas y posiciones dependen de la máquina en concreto.

En algunos entornos los componentes se colocan con coordenadas absolutas. En Java se desaconseja esa práctica porque en la mayoría de casos es imposible prever el tamaño de un componente.

Por tanto, en su lugar, se usan organizadores o también llamados administradores de diseño o layout managers o gestores de distribución que permiten colocar y maquetar de forma independiente de las coordenadas.

Debemos hacer un buen diseño de la interfaz gráfica, y así tenemos que elegir el mejor gestor de distribución para cada uno de los contenedores o paneles de nuestra ventana.

Esto podemos conseguirlo con el método setLayout(), al que se le pasa como argumento un objeto del tipo de Layout que se quiere establecer.

En NetBeans, una vez insertado un JFrame, si nos situamos sobre él y pulsamos botón derecho, se puede ver, como muestra la imagen, que aparece un menú, el cual nos permite elegir el layout que queramos.

Es la clase utilizada como contenedor genérico para agrupar componentes.
Normalmente cuando una ventana de una aplicación con interfaz gráfica cualquiera presenta varios componentes, para hacerla más atractiva y ordenada al usuario se suele hacer lo siguiente:

• Crear un marco, un JFrame.
• Para organizar mejor el espacio en la ventana, añadiremos varios paneles, de tipo JPanel. (Uno para introducir los datos de entrada, otro para mostrar los resultados y un tercero como zona de notificación de errores.)
• Cada uno de esos paneles estará delimitado por un borde que incluirá un título. Para ello se usan las clases disponibles en BorderFactory (BevelBorder, CompoundBorder, EmptyBorder, EtchedBorder, LineBorder, LoweredBevelBorder, MatteBorder y TitledBorder) que nos da un surtido más o menos amplio de tipos de bordes a elegir.
• En cada uno de esos paneles se incluyen las etiquetas y cuadros de texto que se necesitan para mostrar la información adecuadamente.

Con NetBeans es tan fácil como arrastrar tantos controles JPanel de la paleta hasta el JFrame. Por código, también es muy sencillo, por ejemplo podríamos crear un panel rojo, darle sus características y añadirlo al JFrame del siguiente modo:

Cuando en Sun desarrollaron Java, los diseñadores de Swing, por alguna circunstancia, determinaron que para algunas funciones, como añadir un JComponent, los programadores no pudiéramos usar JFrame.add, sino que en lugar de ello, primeramente, tuviéramos que obtener el objeto Container asociado con JFrame.getContentPane(), y añadirlo.

Sun se dio cuenta del error y ahora permite utilizar JFrame.add, desde Java 1.5 en adelante. Sin embargo, podemos tener el problema de que un código desarrollado y ejecutado correctamente en 1.5 falle en máquinas que tengan instalado 1.4 o anteriores.

Los cuadros de texto Swing vienen implementados en Java por la clase JTextField.

Para insertar un campo de texto, el procedimiento es tan fácil como: seleccionar el botón correspondiente a JTextField en la paleta de componentes, en el diseñador, y pinchar sobre el área de diseño encima del panel en el que queremos situar ese campo de texto. El tamaño y el lugar en el que se sitúe, dependerá del Layout elegido para ese panel.

El componente Swing etiqueta JLabel, se utiliza para crear etiquetas de modo que podamos insertarlas en un marco o un panel para visualizar un texto estático, que no puede editar el usuario.
Los constructores son:

• JLabel(). Crea un objeto JLabel sin nombre y sin ninguna imagen asociada.
• JLabel(Icon imagen). Crea un objeto sin nombre con una imagen asociada.
• JLabel(Icon imagen, int alineacionHorizontal). Crea una etiqueta con la imagen especificada y la centra en horizontal.
• JLabel(String texto). Crea una etiqueta con el texto especificado.
• JLabel(String texto, Icon icono, int alineacionHorizontal). Crea una etiqueta con el texto y la imagen especificada y alineada horizontalmente.
• JLabel(String texto, int alineacionHorizontal). Crea una etiqueta con el texto especificado y alineado horizontalmente.

Si quieres conocer en profunidad las clases JLabel y JTextField, puedes consultar la documentación de Java.

Propiedades de JLabel

Propiedades de JTextField

Ya has podido comprobar que prácticamente todas las aplicaciones incluyen botones que al ser pulsados efectúan alguna acción: hacer un cálculo, dar de alta un libro, aceptar modificaciones, etc.

Estos botones se denominan botones de acción, precisamente porque realizan una acción cuando se pulsan. En Swing, la clase que los implementa en Java es laJButton.

Los principales métodos son:

• void setText(String). Asigna el texto al botón.
• String getText(). Recoge el texto.

Hay un tipo especial de botones, que se comportan como interruptores de dos posiciones o estados (pulsados-on, no pulsados-off). Esos botones especiales se denominan botones on/off o JToggleButton.

Las casillas de verificación en Swing están implementadas para Java por la clase JCheckBox, y los botones de radio o de opción por la clase JRadioButton. Los grupos de botones, por la clase ButtonGroup.

La funcionalidad de ambos componentes es en realidad la misma.

• Ambos tienen dos "estados": seleccionados o no seleccionados (marcados o no marcados).
• Ambos se marcan o desmarcan usando el método setSelected(boolean estado), que establece el valor para su propiedad selected. (El estado toma el valor true para seleccionado y false para no seleccionado).
• A ambos le podemos preguntar si están seleccionados o no, mediante el método isSelected(), que devuelve true si el componente está seleccionado y false si no lo está.
• Para ambos podemos asociar un icono distinto para el estado de seleccionado y el de no seleccionado.

JCheckBox pueden usarse en menús mediante la clase JCheckBoxMenuItem.

JButtonGroup permite agrupar una serie de casillas de verificación (JRadioButton), de entre las que sólo puede seleccionarse una. Marcar una de las casillas implica que el resto sean desmarcadas automáticamente. La forma de hacerlo consiste en añadir un JButtonGroup y luego, agregarle los botones.

Cuando en un contenedor aparezcan agrupados varios botones de radio (o de opción), entenderemos que no son opciones independientes, sino que sólo uno de ellos podrá estar activo en cada momento, y necesariamente uno debe estar activo. Por tanto en ese contexto entendemos que son opciones excluyentes entre sí.

En casi todos los programas, nos encontramos con que se pide al usuario que introduzca un dato, y además un dato de entre una lista de valores posibles, no un dato cualquiera.

La clase JList constituye un componente lista sobre el que se puede ver y seleccionar uno o varios elementos a la vez. En caso de haber más elementos de los que se pueden visualizar, es posible utilizar un componente JScrollPanel para que aparezcan barras de desplazamiento.

En los componentes JList, un modelo code>ListModel representa los contenidos de la lista. Esto significa que los datos de la lista se guardan en una estructura de datos independiente, denominada modelo de la lista. Es fácil mostrar en una lista los elementos de un vector o array de objetos, usando un constructor de JList que cree una instancia de ListModel automáticamente a partir de ese vector.

Vemos a continuación un ejemplo parar crear una lista JList que muestra las cadenas contenidas en el vector info[]:

String[] info = {"Pato", "Loro", "Perro", "Cuervo"};

JList listaDatos = new JList(info);

/* El valor de la propiedad model de JList es un objeto que proporciona una visión de sólo lectura del vector info[].

El método getModel() permite recoger ese modelo en forma de Vector de objetos, y utilizar con los métodos de la clase

Vector, como getElementAt(i), que proporciona el elemento de la posición i del Vector.  */

for (int i = 0; i < listaDatos.getModel().getSize(); i++) {

System.out.println(listaDatos.getModel().getElementAt(i));

}

Cuando trabajamos con un componente JList, podemos seleccionar un único elemento, o varios elementos a la vez, que a su vez pueden estar contiguos o no contiguos. La posibilidad de hacerlo de una u otra manera la establecemos con la propiedad selectionMode.

Los valores posibles para la propiedad selectionMode para cada una de esas opciones son las siguientes constantes de clase del interface ListSelectionModel:

• MULTIPLE_INTERVAL_SELECTION: Es el valor por defecto. Permite seleccionar múltiples intervalos, manteniendo pulsada la tecla CTRL mientras se seleccionan con el ratón uno a uno, o la tecla de mayúsculas, mientras se pulsa el primer elemento y el último de un intervalo.
• SINGLE_INTERVAL_SELECTION: Permite seleccionar un único intervalo, manteniendo pulsada la tecla mayúsculas mientras se selecciona el primer y último elemento del intervalo.
• SINGLE_SELECTION: Permite seleccionar cada vez un único elemento de la lista.

Podemos establecer el valor de la propiedad selectedIndex con el método setSelectedIndex() es decir, el índice del elemento seleccionado, para seleccionar el elemento del índice que se le pasa como argumento.

Como hemos comentado, los datos se almacenan en un modelo que al fin y al cabo es un vector, por lo que tiene sentido hablar de índice seleccionado.

También se dispone de un método getSelectedIndex() con el que podemos averiguar el índice del elemento seleccionado.

El método getSelectecValue() devuelve el objeto seleccionado, de tipo Object, sobre el que tendremos que aplicar un "casting" explícito para obtener el elemento que realmente contiene la lista (por ejemplo un String). Observa que la potencia de usar como modelo un vector de Object, es que en el JList podemos mostrar realmente cualquier cosa, como por ejemplo, una imagen.

El método setSelectedValue() permite establecer cuál es el elemento que va a estar seleccionado.

Si se permite hacer selecciones múltiples, contamos con los métodos:

• setSelectedIndices(), al que se le pasa como argumento un vector de enteros que representa los índices a seleccionar.
• getSelectedIndices(), que devuelve un vector de enteros que representa los índices de los elementos o ítems que en ese momento están seleccionados en el JList.
• getSelectedValues(), que devuelve un vector de Object con los elementos seleccionados en ese momento en el JList.

Una lista desplegable se representa en Java con el componente Swing JComboBox. Consiste en una lista en la que sólo se puede elegir una opción. Se pueden crear JComboBox tanto editables como no editables.

Una lista desplegable es una mezcla entre un campo de texto editable y una lista. Si la propiedad editable de la lista desplegable la fijamos a verdadero, o sea a true, el usuario podrá seleccionar uno de los valores de la lista que se despliega al pulsar el botón de la flecha hacia abajo y dispondrá de la posibilidad de teclear directamente un valor en el campo de texto.

Establecemos la propiedad editable del JComboBox el método setEditable() y se comprueba con el método isEditable(). La clase JComboBox ofrece una serie de métodos que tienen nombres y funcionalidades similares a los de la clase JList.

En las aplicaciones informáticas siempre se intenta que el usuario disponga de un menú para facilitar la localización una operación. La filosofía, al crear un menú, es que contenga todas las acciones que el usuario pueda realizar en la aplicación. Lo más normal y útil es hacerlo clasificando o agrupando las operaciones por categorías en submenús.

En Java usamos los componentes JMenu y JMenuItem para crear un menú e insertarlo en una barra de menús. La barra de menús es un componente JMenuBar. Los constructores son los siguientes:

• JMenu(). Construye un menú sin título.
• JMenu(String s). Construye un menú con título indicado por s.
• JMenuItem(). Construye una opción sin icono y sin texto.
• JMenuItem(Icon icono). Construye una opción con icono y con texto.

Podemos construir por código un menú sencillo como el de la imagen con las siguientes sentencias:

 // Crear la barra de menú

 JMenuBar barra = new JMenuBar();

 // Crear el menú Archivo

 JMenu menu = new JMenu("Archivo");

 // Crear las opciones del menú

 JMenuItem opcionAbrir = new JMenuItem("Abrir");

 menu.add(opcionAbrir);

 JMenuItem opcionguardar = new JMenuItem("Guardar");

 menu.add(opcionguardar);

 JMenuItem opcionSalir = new JMenuItem("Salir");

 menu.add(opcionSalir);

 // Añadir las opciones a la barra

 barra.add(menu);

 // Establecer la barra

 setJMenuBar(barra);

Frecuentemente, dispondremos de alguna opción dentro de un menú, que al elegirla, nos dará paso a un conjunto más amplio de opciones posibles.

Cuando en un menú un elemento del mismo es a su vez un menú, se indica con una flechita al final de esa opción, de forma que se sepa que, al seleccionarla, nos abrirá un nuevo menú.

Para incluir un menú como submenú de otro basta con incluir como ítem del menú, un objeto que también sea un menú, es decir, incluir dentro del JMenu un elemento de tipo JMenu.

A veces, en un menú pueden aparecer distintas opciones. Por ello, nos puede interesar destacar un determinado grupo de opciones o elementos del menú como relacionados entre sí por referirse a un mismo tema, o simplemente para separarlos de otros que no tienen ninguna relación con ellos.

El componente Swing que tenemos en Java para esta funcionalidad es: JSeparator, que dibuja una línea horizontal en el menú, y así separa visualmente en dos partes a los componentes de ese menú. En la imagen podemos ver cómo se han separado las opciones de Abrir y Guardar de la opción de Salir, mediante este componente.

Al código anterior, tan sólo habría que añadirle una línea, la que resaltamos en negrita:

...

menu.add(opcionguardar);

menu.add(new JSeparator());

JMenuItem opcionSalir = new JMenuItem("Salir");

...